package com.zysstudy.stream;

import java.util.*;
import java.util.stream.Collectors;

public class practiceStreem2 {

    /**
     * 1. 分组：将 List<User>按年龄分组（Map<Integer, List<User>>）
     * <p>
     * 2.多重分组：先按年龄分组，再按姓名分组（Map<Integer, Map<String, List<User>>>）。
     * <p>
     * 3. 分区：将 List<User>分成成年（age>=18）和未成年（age<18）两个分区。
     * <p>
     * 4.对象转换：将 List<User>转换为 List<UserDTO>（只包含 name 和 age）。
     * <p>
     * 5.过滤并转换：从 List<User>中过滤出年龄大于 18 的用户，并提取他们的姓名。
     * <p>
     * 6. 按条件收集：将 List<Integer>按奇偶分组（Map<String, List<Integer>>，键为 "even" 和 "odd"）。
     * <p>
     * 7.计算平均值：计算 List<User>中用户的平均年龄。
     * <p>
     * 8.获取第一个满足条件的元素：从 List<String>中找出第一个以 "A" 开头的字符串。
     * <p>
     * 9. 判断是否存在：判断 List<User>中是否存在年龄大于 60 的用户。
     * <p>
     * 10.去重并排序：从一个有重复字符串的列表中去重，并按字母顺序排序。
     */
    public static void main(String[] args) {

        practiceStreem2 p = new practiceStreem2();
        Map<Integer, Map<Integer, List<User>>> res = p.p2();
        // 获取 用户中18岁 性别男的 数量
        System.out.println(res.get(18).get(1).size());
        System.out.println(p.p3());
        System.out.println(p.p3().get(true));
        System.out.println(p.p6());
        System.out.println(p.p7());
        System.out.println(p.p8());
        System.out.println(p.p9());
        System.out.println(p.p10());
    }

    //1.分组：将 List<User>按年龄分组（Map<Integer, List<User>>）
    private Map<Integer, List<User>> p1() {
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        return users.stream().collect(Collectors.groupingBy(User::getAge));
    }

    //2.多重分组：先按年龄分组，再按姓名分组（Map<Integer, Map<String, List<User>>>）。
    private Map<Integer, Map<Integer, List<User>>> p2() {
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        return users.stream().collect(Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getSex)));
    }

    //3.分区：将 List<User>分成成年（age>=18）和未成年（age<18）两个分区。
    private Map<Boolean, List<User>> p3() {
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        return users.stream().collect(Collectors.partitioningBy(u -> u.getAge() >= 19));
    }

    //4.对象转换：将 List<User>转换为 List<UserDTO>（只包含 name 和 age）。
    private List<UserDTO> p4() {
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        return users.stream().map(u -> new UserDTO(u.getName(), u.getAge())).collect(Collectors.toList());
    }

    //5.过滤并转换：从 List<User>中过滤出年龄大于 18 的用户，并提取他们的姓名。
    private List<String> p5() {
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        List<User> list = users.stream().filter(s -> s.getAge() > 18).collect(Collectors.toList());
        List<User> list1 = users.stream().filter(s -> s.getAge() > 18).collect(Collectors.toList());
        return users.stream().filter(s -> s.getAge() > 18).map(t -> t.getName()).collect(Collectors.toList());
    }

    //6. 按条件收集：将 List<Integer>按奇偶分组（Map<String, List<Integer>>，键为 "even" 和 "odd"）。
    private Map<String, List<Integer>> p6() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Map<Boolean, List<Integer>> bmap = list.stream().collect(Collectors.partitioningBy(s -> s % 2 == 0));

        Map<String, List<Integer>> map1 = new HashMap<>();
        map1.put("even", bmap.get(true));
        map1.put("odd", bmap.get(false));

        list.stream().collect(Collectors.groupingBy(i -> i % 2 == 0 ? "even" : "odd"));
        return map1;
    }

    //7.计算平均值：计算 List<User>中用户的平均年龄。
    private double p7() {
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        return users.stream().collect(Collectors.averagingDouble(User::getAge));

    }

    //   8.获取第一个满足条件的元素：从 List<String>中找出第一个以 "A" 开头的字符串。

    private String p8() {
        List<String> list = Arrays.asList("abc", "A1245", "Asflsfsldf", "aslfsd", "sfdsdflsd");
        Optional<String> res = list.stream()
                .peek(s -> System.out.println("处理: " + s))
                .filter(s -> s.startsWith("A")).findFirst();
        return res.get();
    }


    // 9.判断是否存在：判断 List<User>中是否存在年龄大于 60 的用户。

    private Boolean p9(){
        List<User> users = Arrays.asList(new User("zys1", 18, 1), new User("zys2", 20, 2),
                new User("zy3s", 18, 1), new User("zy4s", 20, 1));
        return  users.stream().anyMatch(s->s.getAge()>19);
    }

    //10.去重并排序：从一个有重复字符串的列表中去重，并按字母顺序排序。
    private List<String> p10(){

        List<String> list = Arrays.asList("sdjsld","woeiwrwor","wers","sdjsld","woeiwrwor","wers","a","b","ab","ba","abc","bca","cba","a","b","ab");
        System.out.println("没排序前："+list);


        return list.stream().distinct().sorted((a,b)->b.compareTo(a)).collect(Collectors.toList());
    }
}
